home *** CD-ROM | disk | FTP | other *** search
/ AmigActive 10 / AACD 10.iso / AACD / Games / MAME / src / vidhrdw / exterm.c < prev    next >
C/C++ Source or Header  |  2000-04-04  |  9KB  |  320 lines
  1. /***************************************************************************
  2.  
  3.   vidhrdw.c
  4.  
  5.   Functions to emulate the video hardware of the machine.
  6.  
  7. ***************************************************************************/
  8.  
  9. #include "driver.h"
  10. #include "vidhrdw/generic.h"
  11. #include "cpu/tms34010/tms34010.h"
  12.  
  13.  
  14. #define FORCOL_TO_PEN(COL)    \
  15.     if ((COL) & 0x8000)        \
  16.     {                        \
  17.         (COL) &= 0x0fff;    \
  18.     }                        \
  19.     else                    \
  20.     {                        \
  21.         (COL) += 0x1000;    \
  22.     }
  23.  
  24.  
  25. static struct osd_bitmap *tmpbitmap1, *tmpbitmap2;
  26. unsigned char *exterm_master_videoram, *exterm_slave_videoram;
  27.  
  28. void exterm_init_palette(unsigned char *palette, unsigned short *colortable,const unsigned char *color_prom)
  29. {
  30.     int i;
  31.  
  32.     palette += 3*4096;    /* first 4096 colors are dynamic */
  33.  
  34.     /* initialize 555 RGB lookup */
  35.     for (i = 0;i < 32768;i++)
  36.     {
  37.         int r,g,b;
  38.  
  39.         r = (i >> 10) & 0x1f;
  40.         g = (i >>  5) & 0x1f;
  41.         b = (i >>  0) & 0x1f;
  42.  
  43.         (*palette++) = (r << 3) | (r >> 2);
  44.         (*palette++) = (g << 3) | (g >> 2);
  45.         (*palette++) = (b << 3) | (b >> 2);
  46.     }
  47. }
  48.  
  49.  
  50. READ_HANDLER( exterm_master_videoram_r )
  51. {
  52.     return READ_WORD(&exterm_master_videoram[offset]);
  53. }
  54.  
  55. static WRITE_HANDLER( exterm_master_videoram_16_w )
  56. {
  57.     COMBINE_WORD_MEM(&exterm_master_videoram[offset], data);
  58.  
  59.     FORCOL_TO_PEN(data);
  60.  
  61.     ((unsigned short *)tmpbitmap->line[offset >> 9])[(offset >> 1) & 0xff] = Machine->pens[data];
  62. }
  63.  
  64. static WRITE_HANDLER( exterm_master_videoram_8_w )
  65. {
  66.     COMBINE_WORD_MEM(&exterm_master_videoram[offset], data);
  67.  
  68.     FORCOL_TO_PEN(data);
  69.  
  70.     tmpbitmap->line[offset >> 9][(offset >> 1) & 0xff] = Machine->pens[data];
  71. }
  72.  
  73. READ_HANDLER( exterm_slave_videoram_r )
  74. {
  75.     return READ_WORD(&exterm_slave_videoram[offset]);
  76. }
  77.  
  78. static WRITE_HANDLER( exterm_slave_videoram_16_w )
  79. {
  80.     int x,y;
  81.     unsigned short *pens = Machine->pens;
  82.     struct osd_bitmap *foreground;
  83.  
  84.     COMBINE_WORD_MEM(&exterm_slave_videoram[offset], data);
  85.  
  86.     x = offset & 0xff;
  87.     y = (offset >> 8) & 0xff;
  88.  
  89.     foreground = (offset & 0x10000) ? tmpbitmap2 : tmpbitmap1;
  90.  
  91.     ((unsigned short *)foreground->line[y])[x  ] = pens[ (data       & 0xff)];
  92.     ((unsigned short *)foreground->line[y])[x+1] = pens[((data >> 8) & 0xff)];
  93. }
  94.  
  95. static WRITE_HANDLER( exterm_slave_videoram_8_w )
  96. {
  97.     int x,y;
  98.     unsigned short *pens = Machine->pens;
  99.     struct osd_bitmap *foreground;
  100.  
  101.     COMBINE_WORD_MEM(&exterm_slave_videoram[offset], data);
  102.  
  103.     x = offset & 0xff;
  104.     y = (offset >> 8) & 0xff;
  105.  
  106.     foreground = (offset & 0x10000) ? tmpbitmap2 : tmpbitmap1;
  107.  
  108.     foreground->line[y][x  ] = pens[ (data       & 0xff)];
  109.     foreground->line[y][x+1] = pens[((data >> 8) & 0xff)];
  110. }
  111.  
  112. WRITE_HANDLER( exterm_paletteram_w )
  113. {
  114.     if ((offset == 0xff*2) && (data == 0))
  115.     {
  116.         /* Turn shadow color into dark red */
  117.         data = 0x400;
  118.     }
  119.  
  120.     paletteram_xRRRRRGGGGGBBBBB_word_w(offset, data);
  121. }
  122.  
  123.  
  124. #define FROM_SHIFTREG_MASTER(TYPE)                                        \
  125.     int i;                                                                \
  126.     unsigned TYPE *line = &((unsigned TYPE *)tmpbitmap->line[address>>12])[0];    \
  127.     unsigned short *pens = Machine->pens;                                \
  128.                                                                         \
  129.     for (i = 0; i < 256; i++)                                            \
  130.     {                                                                    \
  131.         int data = shiftreg[i];                                            \
  132.                                                                         \
  133.         FORCOL_TO_PEN(data);                                            \
  134.                                                                         \
  135.         *(line++) = pens[data];                                             \
  136.     }                                                                    \
  137.                                                                         \
  138.     memcpy(&exterm_master_videoram[address>>3], shiftreg, 256*sizeof(unsigned short));
  139.  
  140.  
  141. void exterm_to_shiftreg_master(unsigned int address, unsigned short* shiftreg)
  142. {
  143.     memcpy(shiftreg, &exterm_master_videoram[address>>3], 256*sizeof(unsigned short));
  144. }
  145.  
  146. void exterm_from_shiftreg_master(unsigned int address, unsigned short* shiftreg)
  147. {
  148.     if (Machine->scrbitmap->depth == 16)
  149.     {
  150.         FROM_SHIFTREG_MASTER(short);
  151.     }
  152.     else
  153.     {
  154.         FROM_SHIFTREG_MASTER(char);
  155.     }
  156. }
  157.  
  158. #define FROM_SHIFTREG_SLAVE(TYPE)                                        \
  159.     int i;                                                                \
  160.     int y = (address >> 11) & 0xff;                                        \
  161.     unsigned TYPE *line1, *line2;                                        \
  162.     unsigned short *pens = Machine->pens;                                \
  163.                                                                         \
  164.     if (address & 0x80000)                                                \
  165.     {                                                                    \
  166.         line1 = &((unsigned TYPE *)tmpbitmap2->line[y  ])[0];            \
  167.         line2 = &((unsigned TYPE *)tmpbitmap2->line[y+1])[0];            \
  168.     }                                                                    \
  169.     else                                                                \
  170.     {                                                                    \
  171.         line1 = &((unsigned TYPE *)tmpbitmap1->line[y  ])[0];            \
  172.         line2 = &((unsigned TYPE *)tmpbitmap1->line[y+1])[0];            \
  173.     }                                                                    \
  174.                                                                         \
  175.     for (i = 0; i < 256; i++)                                            \
  176.     {                                                                    \
  177.         *(line1++) = pens[((unsigned char*)shiftreg)[i    ]];            \
  178.         *(line2++) = pens[((unsigned char*)shiftreg)[i+256]];            \
  179.     }                                                                    \
  180.                                                                         \
  181.     memcpy(&exterm_slave_videoram[address>>3], shiftreg, 256*2*sizeof(unsigned char));
  182.  
  183.  
  184. void exterm_to_shiftreg_slave(unsigned int address, unsigned short* shiftreg)
  185. {
  186.     memcpy(shiftreg, &exterm_slave_videoram[address>>3], 256*2*sizeof(unsigned char));
  187. }
  188.  
  189. void exterm_from_shiftreg_slave(unsigned int address, unsigned short* shiftreg)
  190. {
  191.     if (Machine->scrbitmap->depth == 16)
  192.     {
  193.         FROM_SHIFTREG_SLAVE(short);
  194.     }
  195.     else
  196.     {
  197.         FROM_SHIFTREG_SLAVE(char);
  198.     }
  199. }
  200.  
  201.  
  202. int exterm_vh_start(void)
  203. {
  204.     if ((tmpbitmap = osd_new_bitmap(Machine->drv->screen_width,Machine->drv->screen_height,Machine->scrbitmap->depth)) == 0)
  205.     {
  206.         return 1;
  207.     }
  208.  
  209.     if ((tmpbitmap1 = osd_new_bitmap(Machine->drv->screen_width,Machine->drv->screen_height,Machine->scrbitmap->depth)) == 0)
  210.     {
  211.         osd_free_bitmap(tmpbitmap);
  212.         return 1;
  213.     }
  214.  
  215.     if ((tmpbitmap2 = osd_new_bitmap(Machine->drv->screen_width,Machine->drv->screen_height,Machine->scrbitmap->depth)) == 0)
  216.     {
  217.         osd_free_bitmap(tmpbitmap);
  218.         osd_free_bitmap(tmpbitmap1);
  219.         return 1;
  220.     }
  221.  
  222.     /* Install depth specific handler */
  223.     if (Machine->scrbitmap->depth == 16)
  224.     {
  225.         install_mem_write_handler(0, TOBYTE(0x00000000), TOBYTE(0x000fffff), exterm_master_videoram_16_w);
  226.         install_mem_write_handler(1, TOBYTE(0x00000000), TOBYTE(0x000fffff), exterm_slave_videoram_16_w);
  227.     }
  228.     else
  229.     {
  230.         install_mem_write_handler(0, TOBYTE(0x00000000), TOBYTE(0x000fffff), exterm_master_videoram_8_w);
  231.         install_mem_write_handler(1, TOBYTE(0x00000000), TOBYTE(0x000fffff), exterm_slave_videoram_8_w);
  232.     }
  233.  
  234.     palette_used_colors[0] = PALETTE_COLOR_TRANSPARENT;
  235.  
  236.     return 0;
  237. }
  238.  
  239. void exterm_vh_stop (void)
  240. {
  241.     osd_free_bitmap(tmpbitmap);
  242.     osd_free_bitmap(tmpbitmap1);
  243.     osd_free_bitmap(tmpbitmap2);
  244. }
  245.  
  246.  
  247. static struct rectangle foregroundvisiblearea =
  248. {
  249.     0, 255, 40, 238
  250. };
  251.  
  252.  
  253. #define REFRESH(TYPE)                                        \
  254.     unsigned TYPE *bg1, *bg2, *fg1, *fg2;                    \
  255.     unsigned short *pens = Machine->pens;                    \
  256.                                                             \
  257.     for (y = 0; y < 256; y++)                                \
  258.     {                                                        \
  259.         bg1  = &((unsigned TYPE *)   bitmap ->line[y])[0];    \
  260.         bg2  = &((unsigned TYPE *)tmpbitmap ->line[y])[0];    \
  261.         fg1  = &((unsigned TYPE *)tmpbitmap1->line[y])[0];    \
  262.         fg2  = &((unsigned TYPE *)tmpbitmap2->line[y])[0];    \
  263.                                                             \
  264.         for (x = 256; x; x--, bgsrc++)                        \
  265.         {                                                    \
  266.             int data = READ_WORD(bgsrc);                    \
  267.             FORCOL_TO_PEN(data);                            \
  268.             *(bg1++) = *(bg2++) = pens[data];                \
  269.         }                                                    \
  270.         for (x = 128; x; x--, fgsrc1++, fgsrc2++)            \
  271.         {                                                    \
  272.             int data1 = READ_WORD(fgsrc1);                    \
  273.             int data2 = READ_WORD(fgsrc2);                    \
  274.             *(fg1++) = pens[data1 & 0xff];                    \
  275.             *(fg1++) = pens[data1 >> 8];                    \
  276.             *(fg2++) = pens[data2 & 0xff];                    \
  277.             *(fg2++) = pens[data2 >> 8];                    \
  278.         }                                                    \
  279.     }
  280.  
  281. void exterm_vh_screenrefresh(struct osd_bitmap *bitmap,int full_refresh)
  282. {
  283.     if (TMS34010_io_display_blanked(0))
  284.     {
  285.         fillbitmap(bitmap,palette_transparent_pen,&Machine->drv->visible_area);
  286.         return;
  287.     }
  288.  
  289.     if (palette_recalc() != 0)
  290.     {
  291.         /* Redraw screen */
  292.         int x,y;
  293.         unsigned short *bgsrc  = (unsigned short *)&exterm_master_videoram[0];
  294.         unsigned short *fgsrc1 = (unsigned short *)&exterm_slave_videoram[0];
  295.         unsigned short *fgsrc2 = (unsigned short *)&exterm_slave_videoram[256*256];
  296.  
  297.         if (tmpbitmap1->depth == 16)
  298.         {
  299.             REFRESH(short);
  300.         }
  301.         else
  302.         {
  303.             REFRESH(char);
  304.         }
  305.     }
  306.     else
  307.     {
  308.         copybitmap(bitmap,tmpbitmap, 0,0,0,0,&Machine->drv->visible_area,TRANSPARENCY_NONE,0);
  309.     }
  310.  
  311.     if (TMS34010_get_DPYSTRT(1) & 0x800)
  312.     {
  313.         copybitmap(bitmap,tmpbitmap2,0,0,0,0,&foregroundvisiblearea,TRANSPARENCY_PEN, palette_transparent_pen);
  314.     }
  315.     else
  316.     {
  317.         copybitmap(bitmap,tmpbitmap1,0,0,0,0,&foregroundvisiblearea,TRANSPARENCY_PEN, palette_transparent_pen);
  318.     }
  319. }
  320.